home *** CD-ROM | disk | FTP | other *** search
/ Java Programmer's Toolkit / Java Programmer's Toolkit.iso / hotjava3 / hotjava3.exe / hotjava / classsrc / java / io / DataOutputStream.java < prev    next >
Encoding:
Java Source  |  1995-08-11  |  5.7 KB  |  244 lines
  1. /*
  2.  * @(#)DataOutputStream.java    1.11 95/01/31 Arthur van Hoff
  3.  *
  4.  * Copyright (c) 1994 Sun Microsystems, Inc. All Rights Reserved.
  5.  *
  6.  * Permission to use, copy, modify, and distribute this software
  7.  * and its documentation for NON-COMMERCIAL purposes and without
  8.  * fee is hereby granted provided that this copyright notice
  9.  * appears in all copies. Please refer to the file "copyright.html"
  10.  * for further important copyright and licensing information.
  11.  *
  12.  * SUN MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE SUITABILITY OF
  13.  * THE SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
  14.  * TO THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
  15.  * PARTICULAR PURPOSE, OR NON-INFRINGEMENT. SUN SHALL NOT BE LIABLE FOR
  16.  * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
  17.  * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES.
  18.  */
  19.  
  20. package java.io;
  21.  
  22. /**
  23.  * This class lets you write primitive Java data types
  24.  * to a stream in a portable way. The data can be converted
  25.  * back using a DataInputStream.
  26.  */
  27.  
  28. public
  29. class DataOutputStream extends FilterOutputStream {
  30.     /**
  31.      * The number of bytes written so far.
  32.      */
  33.     protected int written;
  34.  
  35.     /**
  36.      * Creates a new DataOutputStream
  37.      * @param out    the output stream
  38.      */
  39.     public DataOutputStream(OutputStream out) {
  40.     super(out);
  41.     }
  42.  
  43.     /**
  44.      * Writes a byte. Will block until the byte is actually
  45.      * written.
  46.      * @exception IOException i/o error occurred
  47.      */
  48.     public synchronized void write(int b) {
  49.     out.write(b);
  50.     written++;
  51.     }
  52.  
  53.     /**
  54.      * Writes a sub array of bytes. To be efficient it should
  55.      * be overridden in a subclass. 
  56.      * @param b    the data to be written
  57.      * @param off    the start offset in the data
  58.      * @param len    the number of bytes that are written
  59.      * @exception IOException i/o error occurred
  60.      */
  61.     public synchronized void write(byte b[], int off, int len) {
  62.     out.write(b, off, len);
  63.     written += len;
  64.     }
  65.  
  66.     /**
  67.      * Flushes the stream. This will write any buffered
  68.      * output bytes.
  69.      * @exception IOException i/o error occurred
  70.      */
  71.     public void flush() {
  72.     out.flush();
  73.     }
  74.  
  75.     /**
  76.      * Writes a boolean.
  77.      */
  78.     public final void writeBoolean(boolean v) {
  79.     out.write(v ? 1 : 0);
  80.     written++;
  81.     }
  82.  
  83.     /**
  84.      * Writes an 8 bit byte.
  85.      */
  86.     public final void writeByte(int v) {
  87.     out.write(v);
  88.     written++;
  89.     }
  90.  
  91.     /**
  92.      * Writes a 16 bit short.
  93.      */
  94.     public final void writeShort(int v) {
  95.     OutputStream out = this.out;
  96.     out.write((v >>> 8) & 0xFF);
  97.     out.write((v >>> 0) & 0xFF);
  98.     written += 2;
  99.     }
  100.  
  101.     /**
  102.      * Writes a 16 bit char.
  103.      */
  104.     public final void writeChar(int v) {
  105.     OutputStream out = this.out;
  106.     out.write((v >>> 8) & 0xFF);
  107.     out.write((v >>> 0) & 0xFF);
  108.     written += 2;
  109.     }
  110.  
  111.     /**
  112.      * Writes a 32 bit int.
  113.      */
  114.     public final void writeInt(int v) {
  115.     OutputStream out = this.out;
  116.     out.write((v >>> 24) & 0xFF);
  117.     out.write((v >>> 16) & 0xFF);
  118.     out.write((v >>>  8) & 0xFF);
  119.     out.write((v >>>  0) & 0xFF);
  120.     written += 4;
  121.     }
  122.  
  123.     /**
  124.      * Writes a 64 bit long.
  125.      */
  126.     public final void writeLong(long v) {
  127.     OutputStream out = this.out;
  128.     out.write((int)(v >>> 56) & 0xFF);
  129.     out.write((int)(v >>> 48) & 0xFF);
  130.     out.write((int)(v >>> 40) & 0xFF);
  131.     out.write((int)(v >>> 32) & 0xFF);
  132.     out.write((int)(v >>> 24) & 0xFF);
  133.     out.write((int)(v >>> 16) & 0xFF);
  134.     out.write((int)(v >>>  8) & 0xFF);
  135.     out.write((int)(v >>>  0) & 0xFF);
  136.     written += 8;
  137.     }
  138.  
  139.     /**
  140.      * Writes a 32 bit float.
  141.      */
  142.     public final void writeFloat(float v) {
  143.     writeInt(float2int(v));
  144.     }
  145.  
  146.     /**
  147.      * Writes a 64 bit double.
  148.      */
  149.     public final void writeDouble(double v) {
  150.     writeLong(double2long(v));
  151.     }
  152.  
  153.     /**
  154.      * Writes a string as a sequence of bytes.
  155.      */
  156.     public final void writeBytes(String s) {
  157.     OutputStream out = this.out;
  158.     int len = s.length();
  159.     for (int i = 0 ; i < len ; i++) {
  160.         out.write((byte)s.charAt(i));
  161.     }
  162.     written += len;
  163.     }
  164.  
  165.     /**
  166.      * Writes a string as a sequence of chars.
  167.      */
  168.     public final void writeChars(String s) {
  169.     OutputStream out = this.out;
  170.     int len = s.length();
  171.     for (int i = 0 ; i < len ; i++) {
  172.         int v = s.charAt(i);
  173.         out.write((v >>> 8) & 0xFF);
  174.         out.write((v >>> 0) & 0xFF);
  175.     }
  176.     written += len * 2;
  177.     }
  178.  
  179.     /**
  180.      * Writes string in UTF format.
  181.      */
  182.     public final void writeUTF(String str) {
  183.     OutputStream out = this.out;
  184.     int strlen = str.length();
  185.     int utflen = 0;
  186.  
  187.     for (int i = 0 ; i < strlen ; i++) {
  188.         int c = str.charAt(i);
  189.         if ((c >= 0x0001) && (c <= 0x007F)) {
  190.         utflen++;
  191.         } else if (c > 0x03FF) {
  192.         utflen += 3;
  193.         } else {
  194.         utflen += 2;
  195.         }
  196.     }
  197.  
  198.     out.write((utflen >>> 8) & 0xFF);
  199.     out.write((utflen >>> 0) & 0xFF);
  200.     for (int i = 0 ; i < strlen ; i++) {
  201.         int c = str.charAt(i);
  202.         if ((c >= 0x0001) && (c <= 0x007F)) {
  203.         out.write(c);
  204.         } else if (c > 0x03FF) {
  205.         out.write(0xE0 | ((c >> 12) & 0x0F));
  206.         out.write(0x80 | ((c >>  6) & 0x3F));
  207.         out.write(0x80 | ((c >>  0) & 0x3F));
  208.         written += 2;
  209.         } else {
  210.         out.write(0xC0 | ((c >>  6) & 0x1F));
  211.         out.write(0x80 | ((c >>  0) & 0x3F));
  212.         written += 1;
  213.         }
  214.     }
  215.     written += strlen + 2;
  216.     }
  217.  
  218.     /**
  219.      * Returns number of bytes written.
  220.      * @return    the number of bytes written sofar
  221.      */
  222.     public final int size() {
  223.     return written;
  224.     }
  225.  
  226.     /**
  227.      * Aligns. This is useful when data fields have
  228.      * to be aligned on a n byte boundary.
  229.      * @param n    the number of bytes to align on
  230.      */
  231.     public final void align(int n) {
  232.     OutputStream out = this.out;
  233.     while ((written % n) != 0) {
  234.         out.write(0);
  235.     }
  236.     }
  237.  
  238.     /*
  239.      * Conversions
  240.      */
  241.     private native int float2int(float v);
  242.     private native long double2long(double v);
  243. }
  244.